package Hard;

import java.util.Map;

// 980. 不同路径
/*
 * 思：
 * dp[i][j] 表示到坐标轴为i,j的点时，有dp[i][j]条路线
 * dp[i][j] = dp[i-1][j]+dp[i][j-1]+dp[i][j+1]+dp[i+1][j]
 * 初始化：
 * 如果grid[i][j] == 1 ,则dp[i][j] =1
 * 计算完所有dp的值以后，返回dp[i][j],满足grid[i][j]==2
 * 关键点：
 * 从哪个点开始计算dp？ 从grid[i][j]==1的地方开始计算！ ---> 也不行，需要引入记忆化！
 * 答案的动态规划思路看不懂，放弃
 * ------------------------------------------------------------------------
 * 思2：dfs
 * 从grid[i][j] == 1的地方开始深搜
 *   如果当前格子不为-1（没走过或者没障碍），则将本格子变为-1（代表走过了）
 *   然后上下左右进行dfs
 *   上下左右都执行完了以后，将本格子变为0（每次结束一个方向，就要变为0）
 *   如果找到一条路线，使得能找到grid[i][j]==2 则总路线数+1
 *   如果无路可走，则为递归出口
 * 深搜完毕后，返回总路线数
 * */
public class Solution980 {
    public static int uniquePathsIII(int[][] grid) {
        // 总路线数
        int res[] = new int[1];
        res[0] = 0;
        // 寻找起点
        int x = -1, y = -1;
        int todo = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    x = i;
                    y = j;
                }
                if (grid[i][j] != -1)
                    todo++;
            }
        }
        // 初始化todo，todo代表还未走过的格子
        todo--; // 第一个格子在第一次深搜的时候就已经走过了
        // 开始深搜
        grid[x][y] = -1;
        dfs(grid, x, y, res, todo);
        return res[0];
    }

    public static void dfs(int[][] grid, int x, int y, int[] res, int todo) {
        int R = grid.length;
        int C = grid[0].length;

        boolean left = false, right = false, up = false, down = false;
        // true代表这个格子不能走，也不用递归
        if (x - 1 < 0 || grid[x - 1][y] == -1)
            up = true;
        if (x + 1 >= R || grid[x + 1][y] == -1)
            down = true;
        if (y - 1 < 0 || grid[x][y - 1] == -1)
            left = true;
        if (y + 1 >= C || grid[x][y + 1] == -1)
            right = true;
        // 判定递归结束
        if (left && right && up && down) {
            return;
        }

        // 首先走过false这个格子,如果为2且 todo==1（就剩下这个格子还没走） 则找到一条路线，否则变为-1
        // 然后dfs这个格子，每次dfs结束后，都要将这个格子变为0
        if (!up) {
            if (grid[x - 1][y] == 2 && todo == 1) {
                res[0]++;
            } else if (grid[x - 1][y] != 2) {
                // 如果找到了2，但是还没有走完所有的格子，那么也不能先走 2 这个格子 --> 只有这个格子不为2的时候，才会走这个格子
                grid[x - 1][y] = -1;
                dfs(grid, x - 1, y, res, todo - 1);
                grid[x - 1][y] = 0;
            }

        }
        if (!down) {
            if (grid[x + 1][y] == 2 && todo == 1) {
                res[0]++;
            } else if (grid[x + 1][y] != 2) {
                grid[x + 1][y] = -1;
                dfs(grid, x + 1, y, res, todo - 1);
                grid[x + 1][y] = 0;
            }
        }
        if (!left) {
            if (grid[x][y - 1] == 2 && todo == 1) {
                res[0]++;
            } else if (grid[x][y - 1] != 2) {
                grid[x][y - 1] = -1;
                dfs(grid, x, y - 1, res, todo - 1);
                grid[x][y - 1] = 0;
            }
        }
        if (!right) {
            if (grid[x][y + 1] == 2 && todo == 1) {
                res[0]++;
            } else if (grid[x][y + 1] != 2) {
                grid[x][y + 1] = -1;
                dfs(grid, x, y + 1, res, todo - 1);
                grid[x][y + 1] = 0;
            }
        }

    }

    public static void main(String[] args) {
        System.out.println(uniquePathsIII(new int[][]{{1, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 2, -1}}));
    }
}
